Acquisition.c

Go to the documentation of this file.

#include "derivative.h"
#include "compile_options.h"
#include "HAL.h"
#include "Acquisition.h"
#include "SM.h"
#include "SBC_AL.h"
#include "Central_Accel_AL.h"
#include "MailScheduler.h"
#include "Application_Globals.h"
/*
 ******************************************************************************
 * Constants
 ******************************************************************************
 */
const uint16_t cau16PreAcquiValidStates[] =
{
  SM_STATE_SETUP, SM_STATE_ERROR, SM_STATE_GUI, SM_STATE_DEPLOYMENT };
/*
 ******************************************************************************
 * Globals
 ******************************************************************************
 */

/*
 ******************************************************************************
 * u32fnStateAcquisition
 ******************************************************************************
 */
uint32_t u32fnStateAcquisition(void)
{
  uint32_t u32Status;
  
  /* State variable listing follows */
  uint32_t au32PSI5SatRawResponses[20u];
  uint16_t au16CentralAccelRawResponses[20u];
  uint8_t u8Tries;
  uint8_t u8PerformFilter;

  /* Verify that we can execute - Previous state ended correctly */
  u32Status = u32fnSMValidateCurrentState((uint16_t*)cau16PreAcquiValidStates,
                                          N_ELEMENTS(cau16PreAcquiValidStates));
  if(CLEAR == u32Status)
  {
    /* Here comes the real contents of the state */
    LOCK_STATE_EXECUTION();
    /*-----------------------------------------------------------------------*/
    /* Init tries counter */
    u8Tries = CLEAR;
    
    /* Init the Perform Filter */
    u8PerformFilter = (PERFORM_CA | PERFORM_PSI);
    /* Schedule acceleration from all sensors */
    /* Read Reference accelerometer: Results should be placed in an array */

#ifdef USE_AUTO_SYNC
    while((SCHED_100US_PERIOD * 4u) > u32fnSchedHasTimeElapsed(gu32SMCycleStartTime))
    {
      /* We need to ensure enough time has passed before reading */
    }
#else
    /* Synchronize with WD - otherwise we might have timing issues        */
    /* Note that the chosen sync time is not arbitrary, but a requirement */
    /* to ensure proper WD deployment once a firing event has occurred.   */
    (void)u8fnSBCSyncSM(1u);
    
    /* Send Sync */
    (void)u8fnSBCSchedulePSync();
#endif
    do
    {
      u32Status = CLEAR;
      /* Read back PSI5 sensors through SBC: Results are placed in the same  */
      /* array as the main accelerometer's array.                            */
      if(u8PerformFilter & PERFORM_CA)
      {
        u32Status = u32fnCAScheduleAccelXY((uint16_t*)&au16CentralAccelRawResponses);
      }
      else
      {
        /* Don't Perform */
      }
      if(CLEAR == u32Status)
      {
        /* Message got scheduled correctly */
        u8PerformFilter &= ~PERFORM_CA;
        
        
        if(u8PerformFilter & PERFORM_PSI)
        {
          u32Status = u32fnSBCSchedulePSISat((uint16_t*)&au32PSI5SatRawResponses);
        }
        else
        {
          /* Don't perform */
        }
        
        /***** Seat-buckle reading should be performed at this time. *****/
        
        if(CLEAR == u32Status)
        {
          /* Message got scheduled correctly */
          u8PerformFilter &= ~PERFORM_PSI;
        }
        else
        {
          
        }
        
      } /* End if scheduling central accelerometer */
      else
      {
        /* Not happy about central accelerometer data */
      } /* End else scheduling central accelerometer */ 
      
      while(1 > u32fnSchedIsTxDone(gu32SBCTime))
      {
        /* Wait here */
      };
      SCHED_WHAT_IS_THE_TIME(gu32SMCycleStartTime);
    }while((CLEAR != u32Status) &(MAX_NUMBER_OF_ACQUI_SCHEDULING_TRIES > u8Tries++));
    
    if(CLEAR == u32Status)
    {
      /* Note that for Mesquite/Sycamore, the first byte is throw- */
      /* away and will be overwritten next.                        */
      u32Status = u32fnCAExtractXY((uint16_t*)au16CentralAccelRawResponses,
            (uint16_t*)&(gau16RawAccels[SM_CA_GLOBAL_INDEX]));
      
      /* Interpret acceleration from all devices */
      u32Status |= u32fnSBCExtractPSISat((uint16_t*)&au32PSI5SatRawResponses,
          (uint16_t*)&(gau16RawAccels[SM_PSI5_GLOBAL_INDEX]));
      
      /* Verify that we still have satellites */
      if(CLEAR != gu16ActivePSI5Channels)
      {
        /* We will continue to loop */
      }
      else
      {
        /* Force the status to all satellites crashed -  we will treat in */
        /* the error case. */
        u32Status |= (SAT_CH0_SLOT0_CRASHED | SAT_CH0_SLOT1_CRASHED | 
                     SAT_CH0_SLOT2_CRASHED | SAT_CH1_SLOT0_CRASHED | 
                     SAT_CH1_SLOT1_CRASHED | SAT_CH1_SLOT2_CRASHED |
                     SAT_CH2_SLOT0_CRASHED | SAT_CH2_SLOT1_CRASHED | 
                     SAT_CH2_SLOT2_CRASHED | SAT_CH3_SLOT0_CRASHED | 
                     SAT_CH3_SLOT1_CRASHED | SAT_CH3_SLOT2_CRASHED);
      }
      
      
    }
    else
    {
      /* Exit already */
    }
    
    /*-----------------------------------------------------------------------*/
    
    /* Unlock the state */
    UNLOCK_STATE_EXECUTION();
  } /* End if for State is valid */
  else
  {
    /* Leave */
  } /* End else for State is valid */
  
  /* Set the next state */
  if(CLEAR == u32Status)
  {
    vfnSMWriteNextState(SM_STATE_DECISION);
  }
  else
  {
    vfnSMWriteNextState(SM_STATE_ERROR);
  }
  return (u32Status);
}
/*
 ******************************************************************************
 *
 *  End of file.
 *
 ******************************************************************************
 */